#include <iostream>
using namespace std;

#include "tcomplejo.h"
#include <math.h>

//! \file tcomplejo.cpp
//! \brief Implementacion de la clase TComplejo

TComplejo::TComplejo(double ent,double img):re(ent), im(img) {};

TComplejo::TComplejo(const TComplejo & n)
{
	this->re = n.re;
	this->im = n.im;
}

TComplejo::~TComplejo()
{
	re = im = 0.0;
}


TComplejo&
TComplejo::operator= (const TComplejo& n)
{
	if (this != &n)
	{
		this->re = n.re;
		this->im = n.im;
	}
	return *this;	
}

TComplejo
TComplejo::operator+ (const TComplejo& n)
{
	TComplejo ret;
	ret.re = this->re + n.re;
	ret.im = this->im + n.im;
	
	return ret;
}

TComplejo
TComplejo::operator- (const TComplejo& n)
{
	TComplejo ret;
	ret.re = this->re - n.re;
	ret.im = this->im - n.im;
	
	return ret;
}

TComplejo
TComplejo::operator* (const TComplejo& n)
{
	TComplejo ret;
	ret.re = (this->re * n.re) - (this->im * n.im);
	ret.im = (this->im * n.re) + (this->re * n.im);
	
	return ret;
}

TComplejo
TComplejo::operator+ (const double n)
{
	TComplejo ret;
	ret.re = this->re + n;
	ret.im = this->im;
	
	return ret;	
}

TComplejo
TComplejo::operator- (const double n)
{
	TComplejo ret;
	ret.re = this->re - n;
	ret.im = this->im;
	
	return ret;	
}

TComplejo
TComplejo::operator* (const double n)
{
	TComplejo ret;
	ret.re = this->re * n;
	ret.im = this->im * n;
	
	return ret;	
}

TComplejo
operator+ (const double n, const TComplejo& c)
{
	TComplejo ret;
	ret.re = n + c.re;
	ret.im = c.im;
	
	return ret;
}

TComplejo
operator- (const double n, const TComplejo& c)
{
	TComplejo ret;
	ret.re = n - c.re;
	ret.im = -c.im;
	
	return ret;
}

TComplejo
operator* (const double n, const TComplejo& c)
{
	TComplejo ret;
	ret.re = n * c.re;
	ret.im = n * c.im;
	
	return ret;
}


bool
TComplejo::operator== (const TComplejo& n) const
{
	return (n.re == this->re && n.im == this->im);
}

bool
TComplejo::operator!= (const TComplejo& n) const
{
	return !(n.re == this->re && n.im == this->im);
}

bool
TComplejo::operator< (const TComplejo& n) const 
{
	bool ret = false;
	if (n.Mod() > Mod())
	{
		ret = true;
	}
	if (n.Mod() == Mod())
	{
		if (n.Re() > Re())
		{
			ret = true;
		}
		if (n.Re() == Re())
		{
			if (n.Im() > Im())
			{
				ret = true;
			}
		}
	}
	return ret;
}

bool
TComplejo::operator>(const TComplejo &c) const
{
	return !(*this<c) && *this!=c;
}

double
TComplejo::Re() const
{
	return this->re;
}

double
TComplejo::Im() const
{
	return this->im;
}

void
TComplejo::Re(const double n)
{
	this->re = n;
}

void
TComplejo::Im(const double n)
{
	this->im = n;
}

double
TComplejo::Arg() const
{
	return atan2(im, re);
}

double
TComplejo::Mod() const
{
	return sqrt(im*im+re*re);
}

ostream& 
operator<< (ostream &os, const TComplejo &n)
{
	os <<'(' <<n.re <<' ' <<n.im <<')' ;
	return os;
}
